// 阅读量数据管理服务
let viewsData = {}

// 解析txt格式的阅读量数据
function parseViewsTxt(txtContent) {
  const data = {}
  if (txtContent) {
    txtContent.split('\n').forEach(line => {
      const parts = line.split(':')
      if (parts.length === 2) {
        data[parts[0].trim()] = parseInt(parts[1].trim(), 10) || 0
      }
    })
  }
  return data
}

// 将数据转换为txt格式
function formatViewsToTxt(data) {
  return Object.entries(data)
    .map(([filename, views]) => `${filename}:${views}`)
    .join('\n')
}

// 从Data文件夹下的views.txt文件加载阅读量
export async function loadViewsData() {
  try {
    // 首先检查localStorage中是否有更新的数据
    const localData = localStorage.getItem('blog_views_data')
    const lastUpdated = localStorage.getItem('views_data_updated')
    
    if (localData && lastUpdated) {
      // 如果localStorage中有数据且最近更新过，优先使用localStorage数据
      viewsData = parseViewsTxt(localData)
      console.log('从localStorage加载阅读量数据:', viewsData)
      return
    }
    
    // 尝试从Data文件夹读取views.txt文件
    const response = await fetch('/src/Data/views.txt')
    if (response.ok) {
      const txtContent = await response.text()
      viewsData = parseViewsTxt(txtContent)
      console.log('从Data/views.txt加载阅读量数据:', viewsData)
      
      // 将文件数据同步到localStorage
      localStorage.setItem('blog_views_data', txtContent)
    } else {
      // 如果文件不存在，使用默认数据
      const defaultTxt = `JIT说明.md:1
SystemInfo说明.md:89
字节码说明.md:23
机器码说明.md:178
面试.md:2`
      viewsData = parseViewsTxt(defaultTxt)
      console.log('使用默认阅读量数据:', viewsData)
      
      // 将默认数据保存到localStorage
      localStorage.setItem('blog_views_data', defaultTxt)
    }
  } catch (error) {
    console.error('读取Data/views.txt文件失败:', error)
    
    // 尝试从localStorage恢复数据
    const localData = localStorage.getItem('blog_views_data')
    if (localData) {
      viewsData = parseViewsTxt(localData)
      console.log('从localStorage恢复阅读量数据:', viewsData)
    } else {
      // 使用默认数据作为后备
      const defaultTxt = `JIT说明.md:1
SystemInfo说明.md:89
字节码说明.md:23
机器码说明.md:178
面试.md:2`
      viewsData = parseViewsTxt(defaultTxt)
      console.log('使用后备阅读量数据:', viewsData)
    }
  }
}

// 保存阅读量数据到localStorage和更新views.txt文件
export function saveViewsData() {
  try {
    const txtContent = formatViewsToTxt(viewsData)
    localStorage.setItem('blog_views_data', txtContent)
    console.log('阅读量数据已保存到localStorage:', viewsData)
    
    // 尝试更新views.txt文件（通过API调用）
    updateViewsTxtFile(txtContent)
    
    return true
  } catch (error) {
    console.error('保存阅读量数据失败:', error)
    return false
  }
}

// 更新views.txt文件（模拟文件更新）
async function updateViewsTxtFile(txtContent) {
  try {
    // 在实际应用中，这里应该调用后端API来更新文件
    // 目前我们只能更新localStorage，并在下次加载时使用
    console.log('模拟更新views.txt文件:', txtContent)
    
    // 可以在这里添加一个标记，表示数据已更新
    localStorage.setItem('views_data_updated', Date.now().toString())
    
    return true
  } catch (error) {
    console.error('更新views.txt文件失败:', error)
    return false
  }
}

// 获取文章阅读量
export function getViews(filename) {
  return viewsData[filename] || 0
}

// 防重复点击的阅读量记录
const viewIncrements = new Set()

// 增加文章阅读量
export function incrementViews(filename) {
  // 创建唯一标识符，防止同一会话中重复增加
  const sessionKey = `${filename}_${Date.now()}_${Math.random()}`
  
  if (!viewsData[filename]) {
    viewsData[filename] = 0
  }
  
  // 增加阅读量
  viewsData[filename]++
  
  // 记录本次增加，防止重复
  viewIncrements.add(sessionKey)
  
  // 保存数据
  saveViewsData()
  
  console.log('阅读量已增加:', filename, '当前阅读量:', viewsData[filename])
  
  // 触发数据更新事件（用于实时更新UI）
  window.dispatchEvent(new CustomEvent('viewsUpdated', {
    detail: { filename, views: viewsData[filename] }
  }))
  
  return viewsData[filename]
}

// 检查是否已经增加过阅读量（基于时间窗口）
export function hasIncrementedRecently(filename, timeWindow = 5000) {
  const now = Date.now()
  const recentIncrements = Array.from(viewIncrements).filter(key => {
    const timestamp = parseInt(key.split('_')[1])
    return now - timestamp < timeWindow
  })
  
  return recentIncrements.some(key => key.startsWith(filename))
}

// 获取总阅读量
export function getTotalViews() {
  const total = Object.values(viewsData).reduce((sum, views) => sum + views, 0)
  console.log('计算总阅读量:', total, viewsData)
  return total
}

// 获取当前阅读量数据
export function getViewsData() {
  return viewsData
}

// 手动更新阅读量数据（用于测试）
export function updateViewsData(newData) {
  viewsData = { ...newData }
  saveViewsData()
  console.log('阅读量数据已手动更新:', viewsData)
}

// 获取数据同步状态
export function getDataSyncStatus() {
  const localData = localStorage.getItem('blog_views_data')
  const lastUpdated = localStorage.getItem('views_data_updated')
  
  return {
    hasLocalData: !!localData,
    lastUpdated: lastUpdated ? new Date(parseInt(lastUpdated)) : null,
    dataCount: Object.keys(viewsData).length,
    totalViews: getTotalViews()
  }
}

// 强制重新加载数据
export async function forceReloadData() {
  // 清除localStorage缓存
  localStorage.removeItem('blog_views_data')
  localStorage.removeItem('views_data_updated')
  
  // 重新加载数据
  await loadViewsData()
  console.log('数据已强制重新加载:', viewsData)
}

// 导出当前数据为txt格式（用于备份）
export function exportDataAsTxt() {
  return formatViewsToTxt(viewsData)
}

// 从txt格式导入数据
export function importDataFromTxt(txtContent) {
  try {
    const newData = parseViewsTxt(txtContent)
    viewsData = { ...newData }
    saveViewsData()
    console.log('数据已从txt导入:', viewsData)
    return true
  } catch (error) {
    console.error('导入数据失败:', error)
    return false
  }
}

// 初始化数据
loadViewsData()
